static void swap_loghdr(struct loghdr* loghdr,
void (*swap16_func)(void*), void (*swap32_func)(void*))
{
- int i;
-
if (swap16_func != nullptr) {
swap16_func(&(loghdr->num));
swap16_func(&(loghdr->next));
swap32_func(&(loghdr->date));
swap32_func(&(loghdr->time));
}
- for (i=0; i<MAXTRK; i++) {
+ for (int i = 0; i<MAXTRK; i++) {
swap_trkhdr(&(loghdr->trkhdr[i]), swap16_func, swap32_func);
}
}
{
void (*swap16_func)(void*);
void (*swap32_func)(void*);
- int i;
switch (byte_order()) {
case SWAP_NONE: /* same byte oder, LITTLE_ENDIAN */
}
swap_loghdr(&(trldata->loghdr), swap16_func, swap32_func);
- for (i=0; i<MAXTRK; i++) {
+ for (int i = 0; i<MAXTRK; i++) {
swap_trklog(&(trldata->trklog[i]), swap16_func, swap32_func);
}
}
static int find_wpt(struct wprdata* wprdata, const Waypoint* WP)
{
struct wpt pattern, *wpt;
- int i, wpt_idx;
+ int wpt_idx;
str2lab(pattern.name, WP->shortname, WPT_NAME_LEN, nullptr, 0);
pattern.pt.x = deg2pt(WP->longitude);
pattern.pt.y = deg2pt(-WP->latitude);
wpt = wprdata->wpt;
- for (i=0; i<MAXWPT; i++) {
+ for (int i = 0; i<MAXWPT; i++) {
wpt_idx = wprdata->wpthdr.idx[i];
if (wpt_idx == WPT_IDX_NONE ||
wprdata->wpthdr.used[wpt_idx] == WPT_UNUSED) {
static void
wr_init(const QString& fname)
{
- int i;
int l = fname.length();
char obuf[20] = { 0 } ;
char* p = obuf;
file_out = gbfopen_le(fname, "w", MYNAME);
trkpt_count = 0;
QString fnameu = fname.toUpper();
- for (i = 0; (i < l) && (i < 20); i++) {
+ for (int i = 0; (i < l) && (i < 20); i++) {
char c = fnameu[i].toLatin1();
if (isalnum(c)) {
*p++ = c;
void
cet_deregister()
{
- int i;
int j = cet_cs_alias_ct;
cet_cs_alias_t* p = cet_cs_alias;
cet_cs_alias_ct = 0;
cet_cs_alias = nullptr;
- for (i = 0; i < j; i++) {
+ for (int i = 0; i < j; i++) {
xfree(p[i].name);
}
xfree(p);
/* helper functions */
static struct dg100_command*
dg100_findcmd(int id) {
- unsigned int i;
-
/* linear search should be OK as long as dg100_numcommands is small */
- for (i = 0; i < model->numcommands; i++) {
+ for (unsigned int i = 0; i < model->numcommands; i++) {
if (model->commands[i].id == id) {
return(&model->commands[i]);
}
static void
dg100_debug(const char* hdr, int include_nl, size_t sz, unsigned char* buf)
{
- unsigned int i;
-
/* Only give byte dumps for higher debug levels */
if (global_opts.debug_level < 5) {
return;
fprintf(stderr, "%s", hdr);
- for (i = 0; i < sz; i++) {
+ for (unsigned int i = 0; i < sz; i++) {
fprintf(stderr, "%02x ", buf[i]);
}
dg100_checksum(uint8_t buf[], int count)
{
uint16_t sum = 0;
- int i;
- for (i = 0; i < count; i++) {
+ for (int i = 0; i < count; i++) {
sum += buf[i];
}
sum &= (1<<15) - 1;
while (wcount > 0) {
Waypoint* wpt;
- int32_t namect, i;
+ int32_t namect;
wcount--;
// variants of shortname
- for (i = 0; i < namect; i++) {
+ for (int32_t i = 0; i < namect; i++) {
char* name;
name = read_str(fin);
static void
write_header(const route_head* trk)
{
- int count, i;
+ int count;
const char ZERO = '\0';
header_written = 1;
QString::number(waypt_count()) + " waypoints";
write_str(cout, fout);
- for (i = 3; i <= 8; i++) {
+ for (int i = 3; i <= 8; i++) {
gbfputc(ZERO, fout);
}
write_str("GPSBabel", fout);
uint32_t* exif_ifd_ofs, uint32_t* gps_ifd_ofs, uint32_t* inter_ifd_ofs)
{
queue* elem, *tmp;
- uint16_t i;
exif_ifd_t* ifd;
gbfile* fin = app->fexif;
return ifd;
}
- for (i = 0; i < ifd->count; i++) {
+ for (uint16_t i = 0; i < ifd->count; i++) {
exif_tag_t* tag;
tag = (exif_tag_t*) xcalloc(sizeof(*tag), 1);
debug_print(int level, const char* fmt, ...)
{
va_list ap;
- int i;
- for (i=1; i<level; i++) {
+ for (int i = 1; i<level; i++) {
fprintf(stderr, ".");
}
va_start(ap, fmt);
static void
waypt_read()
{
- int i,n;
+ int n;
GPS_PWay* way = nullptr;
if (getposn) {
fatal(MYNAME ":Can't get waypoint from %s\n", portname);
}
- for (i = 0; i < n; i++) {
+ for (int i = 0; i < n; i++) {
Waypoint* wpt_tmp = new Waypoint;
wpt_tmp->shortname = QString::fromLatin1(way[i]->ident);
int result = 0;
if ((laps != nullptr) && (nlaps > 0)) {
- int i;
- for (i=(nlaps-1); i >= 0; i--) {
+ for (int i = (nlaps-1); i >= 0; i--) {
GPS_PLap lap = laps[i];
time_t delta = lap->start_time - wpt->GetCreationTime().toTime_t();
if ((delta >= -1) && (delta <= 1)) {
GPS_PTrack* array;
route_head* trk_head = nullptr;
int trk_num = 0;
- int i;
const char* trk_name = "";
GPS_PLap* laps = nullptr;
int nlaps = 0;
return;
}
- for (i = 0; i < ntracks; i++) {
+ for (int i = 0; i < ntracks; i++) {
Waypoint* wpt;
/*
route_read()
{
int32 nroutepts;
- int i;
GPS_PWay* array;
/* TODO: Fixes warning but is it right?
* RJL: No, the warning isn't right; GCC's flow analysis is broken.
// fprintf(stderr, "Routes %d\n", (int) nroutepts);
#if 1
- for (i = 0; i < nroutepts; i++) {
+ for (int i = 0; i < nroutepts; i++) {
if (array[i]->isrte) {
char* csrc = nullptr;
/* What a horrible API has libjeeps for making this
static void
waypoint_write()
{
- int i, n;
+ int n;
int32 ret;
n = waypoint_prepare();
fatal(MYNAME ":communication error sending wayoints..\n");
}
- for (i = 0; i < n; ++i) {
+ for (int i = 0; i < n; ++i) {
GPS_Way_Del(&tx_waylist[i]);
}
if (global_opts.verbose_status) {
static void
route_write()
{
- int i;
int n = 2 * route_waypt_count(); /* Doubled for the islink crap. */
tx_routelist = (struct GPS_SWay**) xcalloc(n,sizeof(GPS_PWay));
cur_tx_routelist_entry = tx_routelist;
- for (i = 0; i < n; i++) {
+ for (int i = 0; i < n; i++) {
tx_routelist[i] = sane_GPS_Way_New();
}
static int
track_prepare()
{
- int i;
int32 n = track_waypt_count() + track_count();
tx_tracklist = (struct GPS_STrack**) xcalloc(n, sizeof(GPS_PTrack));
cur_tx_tracklist_entry = tx_tracklist;
- for (i = 0; i < n; i++) {
+ for (int i = 0; i < n; i++) {
tx_tracklist[i] = GPS_Track_New();
}
my_track_count = 0;
static void
track_write()
{
- int i, n;
+ int n;
n = track_prepare();
GPS_Command_Send_Track(portname, tx_tracklist, n, (eraset)? 1 : 0);
- for (i = 0; i < n; i++) {
+ for (int i = 0; i < n; i++) {
GPS_Track_Del(&tx_tracklist[i]);
}
xfree(tx_tracklist);
static int
d103_icon_number_from_symbol(const QString& s)
{
- unsigned int i;
-
if (s.isNull()) {
return 0;
}
- for (i = 0; i < sizeof(d103_icons) / sizeof(d103_icons[0]); i++) {
+ for (unsigned int i = 0; i < sizeof(d103_icons) / sizeof(d103_icons[0]); i++) {
if (0 == (s.compare(d103_icons[i], Qt::CaseInsensitive))) {
return i;
}
static void
fit_rd_deinit()
{
- int local_id;
-
- for (local_id=0; local_id<16; local_id++) {
+ for (int local_id = 0; local_id<16; local_id++) {
fit_message_def* def = &fit_data.message_def[local_id];
if (def->fields) {
xfree(def->fields);
uint8_t cadence = 0xff;
uint16_t power = 0xffff;
int8_t temperature = 0x7f;
- int i;
Waypoint* waypt;
int32_t startlat = 0x7fffffff;
int32_t startlon = 0x7fffffff;
if (global_opts.debug_level >= 7) {
debug_print(7,"%s: parsing fit data ID %d with num_fields=%d\n", MYNAME, def->global_id, def->num_fields);
}
- for (i = 0; i < def->num_fields; i++) {
+ for (int i = 0; i < def->num_fields; i++) {
if (global_opts.debug_level >= 7) {
debug_print(7,"%s: parsing field %d\n", MYNAME, i);
}
writer->writeTextElement(QStringLiteral("gpxx:DisplayMode"), cx);
}
if (gmsd->flags.category && gmsd->category) {
- int i;
uint16_t cx = gmsd->category;
writer->writeStartElement(QStringLiteral("gpxx:Categories"));
- for (i = 0; i < 16; i++) {
+ for (int i = 0; i < 16; i++) {
if (cx & 1) {
writer->writeTextElement(QStringLiteral("gpxx:Category"), QStringLiteral("Category %1").arg(i+1));
}
static void
garmin_gpi_wr_init(const QString& fname)
{
- int i;
-
if (gpi_timestamp != 0) { /* not the first gpi output session */
time_t t = time(nullptr);
if (t <= gpi_timestamp) {
codepage = 0;
- for (i = 1250; i <= 1257; i++) {
+ for (int i = 1250; i <= 1257; i++) {
if (QString("windows-%1").arg(i).compare(QString(opt_writecodec), Qt::CaseInsensitive) == 0) {
codepage = i;
break;
*/
if (find_flag == 0) {
- const char** prefix;
const char* prefixes[] = {
"White ", "Red ", "Green ", "Blue ", "Black ", nullptr
};
// Rewrite "Green Square" to "Square, Green".
- for (prefix = prefixes; *prefix != nullptr; prefix++) {
+ for (const char** prefix = prefixes; *prefix != nullptr; prefix++) {
if (desc.startsWith(*prefix, Qt::CaseInsensitive)) {
QString buff = desc;
buff.replace(*prefix, "");
grid_type
gt_lookup_grid_type(const char* grid_name, const QString& module)
{
- grid_mapping_t* g;
-
- for (g = gt_mps_grid_names; (g->shortname); g++) {
+ for (grid_mapping_t* g = gt_mps_grid_names; (g->shortname); g++) {
if (QString::compare(grid_name, g->shortname, Qt::CaseInsensitive) == 0 ||
QString::compare(grid_name, g->longname,Qt::CaseInsensitive) == 0) {
return g->grid;
gt_get_mps_datum_name(const int datum_index)
{
const char* result;
- datum_mapping_t* d;
result = GPS_Math_Get_Datum_Name(datum_index);
- for (d = gt_mps_datum_names; (d->jeeps_name); d++)
+ for (datum_mapping_t* d = gt_mps_datum_names; (d->jeeps_name); d++)
if (QString::compare(result, d->jeeps_name, Qt::CaseInsensitive) == 0) {
return d->mps_name;
}
int
gt_lookup_datum_index(const char* datum_str, const QString& module)
{
- datum_mapping_t* d;
int result;
const char* name = datum_str;
- for (d = gt_mps_datum_names; (d->jeeps_name); d++) {
+ for (datum_mapping_t* d = gt_mps_datum_names; (d->jeeps_name); d++) {
if (QString::compare(name, d->mps_name, Qt::CaseInsensitive) == 0) {
name = d->jeeps_name;
break;
uint32_t
gt_color_value_by_name(const QString& name)
{
- unsigned int i;
-
- for (i = 0; i < GT_COLORS_CT; i++)
+ for (unsigned int i = 0; i < GT_COLORS_CT; i++)
if (QString::compare(gt_colors[i].name, name, Qt::CaseInsensitive) == 0) {
return gt_colors[i].rgb;
}
int
gt_color_index_by_name(const QString& name)
{
- unsigned int i;
-
- for (i = 0; i < GT_COLORS_CT; i++)
+ for (unsigned int i = 0; i < GT_COLORS_CT; i++)
if (QString::compare(gt_colors[i].name, name, Qt::CaseInsensitive) == 0) {
return i;
}
int
gt_color_index_by_rgb(const int rgb)
{
- unsigned int i;
-
- for (i = 0; i < GT_COLORS_CT; i++)
+ for (unsigned int i = 0; i < GT_COLORS_CT; i++)
if (rgb == gt_colors[i].rgb) {
return i;
}
gmsd = GMSD_FIND(wpt);
wpt_class = GMSD_GET(wpt_class, 0);
if (wpt_class < 0x80) {
- int i;
-
if (gtxt_flags.enum_waypoints) { /* enumerate only */
waypoints++;
return;
}
- for (i = 0; i < wpt_a_ct; i++) { /* check for duplicates */
+ for (int i = 0; i < wpt_a_ct; i++) { /* check for duplicates */
const Waypoint* tmp = wpt_a[i];
if (case_ignore_strcmp(tmp->shortname, wpt->shortname) == 0) {
wpt_a[i] = wpt;
static void
print_categories(uint16_t categories)
{
- int i, count;
+ int count;
char* c;
if (categories == 0) {
}
count = 0;
- for (i = 0; i < 16; i++) {
+ for (int i = 0; i < 16; i++) {
if ((categories & 1) != 0) {
if (global_opts.inifile != nullptr) {
char key[3];
static void
print_string(const char* fmt, const char* string)
{
- char* c;
char* buff;
buff = xstrdup(string);
/* remove unwanted characters from source string */
- for (c = buff; *c; c++) {
+ for (char* c = buff; *c; c++) {
if (iscntrl(*c)) {
*c = ' ';
}
gtxt_flags.enum_waypoints = 0;
if (waypoints > 0) {
- int i;
-
wpt_a_ct = 0;
wpt_a = (const Waypoint**)xcalloc(waypoints, sizeof(*wpt_a));
waypt_disp_all(enum_waypt_cb);
qsort(wpt_a, waypoints, sizeof(*wpt_a), sort_waypt_cb);
gbfprintf(fout, "Header\t%s\r\n\r\n", headers[waypt_header]);
- for (i = 0; i < waypoints; i++) {
+ for (int i = 0; i < waypoints; i++) {
const Waypoint* wpt = wpt_a[i];
write_waypt(wpt);
}
static void
free_header(const header_type ht)
{
- int i;
-
- for (i = 0; i < MAX_HEADER_FIELDS; i++) {
+ for (int i = 0; i < MAX_HEADER_FIELDS; i++) {
char* c = header_lines[ht][i];
if (c != nullptr) {
xfree(c);
static int
parse_display(const char* str, int* val)
{
- gt_display_modes_e i;
-
if ((str == nullptr) || (*str == '\0')) {
return 0;
}
- for (i = GT_DISPLAY_MODE_MIN; i <= GT_DISPLAY_MODE_MAX; i++) {
+ for (gt_display_modes_e i = GT_DISPLAY_MODE_MIN; i <= GT_DISPLAY_MODE_MAX; i++) {
if (case_ignore_strcmp(str, gt_display_mode_names[i]) == 0) {
*val = i;
return 1;
static void
garmin_txt_rd_deinit()
{
- header_type h;
-
- for (h = waypt_header; h <= unknown_header; h++) {
+ for (header_type h = waypt_header; h <= unknown_header; h++) {
free_header(h);
}
gbfclose(fin);
res->description = l.url_;
}
} else { // if (gdb_ver >= GDB_VER_3)
- int i, url_ct;
+ int url_ct;
waypt_flag = 0;
FREAD(buf, 5); /* instruction depended */
res->description = FREAD_CSTR_AS_QSTR; /* instruction */
url_ct = FREAD_i32;
- for (i = url_ct; (i); i--) {
+ for (int i = url_ct; (i); i--) {
QString str = FREAD_CSTR_AS_QSTR;
if (!str.isEmpty()) {
waypt_add_url(res, str, nullptr);
read_route()
{
route_head* rte;
- int points, warnings, links, i;
+ int points, warnings, links;
char buf[128];
bounds bounds;
nice(rte->rte_name), points);
#endif
- for (i = 0; i < points; i++) {
- int wpt_class, j;
+ for (int i = 0; i < points; i++) {
+ int wpt_class;
char buf[128];
garmin_ilink_t* il_root, *il_anchor;
FREAD(buf, 18); /* unknown 18 bytes; but first should be 0x01 or 0x03 */
/* seen also 0 with VER3 */
if ((buf[0] != 0x00) && (buf[0] != 0x01) && (buf[0] != 0x03)) {
- int i;
-
warnings++;
if (warnings > 3) {
fatal(MYNAME "-rte_pt \"%s\": too many warnings!\n", qPrintable(wpt->shortname));
}
warning(MYNAME "-rte_pt \"%s\" (class %d): possible error in route.\n", qPrintable(wpt->shortname), wpt_class);
warning(MYNAME "-rte_pt (dump):");
- for (i = 0; i < 18; i++) {
+ for (int i = 0; i < 18; i++) {
warning(" %02x", (unsigned char)buf[i]);
}
warning("\n");
printf(MYNAME "-rte_pt \"%s\" (%d): %d interlink step(s)\n",
nice(wpt->shortname), wpt_class, links);
#endif
- for (j = 0; j < links; j++) {
+ for (int j = 0; j < links; j++) {
garmin_ilink_t* il_step = (garmin_ilink_t*) xmalloc(sizeof(*il_step));
il_step->ref_count = 1;
read_track()
{
route_head* res;
- int points, index;
+ int points;
char dummy;
int color_idx;
points = FREAD_i32;
- for (index = 0; index < points; index++) {
+ for (int index = 0; index < points; index++) {
Waypoint* wpt = new Waypoint;
trkpt_ct++;
warning(MYNAME ":(%d%c): delta = %d -", gdb_ver, typ, delta);
}
if (delta > 0) {
- int i;
char* buf = (char*) xmalloc(delta);
if (FREAD(buf, delta) < 1) {
fatal(MYNAME ": Attempt to read past EOF.\n");
}
- for (i = 0; i < delta; i++) {
+ for (int i = 0; i < delta; i++) {
warning(" %02x", (unsigned char)buf[i]);
}
xfree(buf);
ggv_ovl_read()
{
int symbols;
- int i;
symbols = inifile_readint_def(inifile, "Overlay", "Symbols", -1);
- for (i = 1; i <= symbols; i++) {
+ for (int i = 1; i <= symbols; i++) {
int points;
OVL_SYMBOL_TYP type;
char symbol[32];
}
if (points > 0) {
- int j;
route_head* rte, *trk;
rte = trk = route_head_alloc();
trk->rte_name = QString("Track %1").arg(track_ct);
}
- for (j = 0; j < points; j++) {
+ for (int j = 0; j < points; j++) {
wpt = new Waypoint;
uint8_t DeviceCommand, len_h, len_l, crc;
uint8_t* payload;
int length;
- int i;
uint8_t calc_crc = 0;
DeviceCommand = recv_byte();
goto error_out;
}
- for (i = 0; i < length; i++) {
+ for (int i = 0; i < length; i++) {
payload[i] = recv_byte();
calc_crc ^= payload[i];
}
int laps_in_package = header.gh_laprec.LapIndex - header.gh_ptrec.Index + 1;
// printf("Lap Data:\n");
uint8_t* lap_start_pos = track_payload + 29; //29=packed sizeof(gh_trainheader)
- int lap;
- for (lap = 0; lap < laps_in_package; lap++) {
+ for (int lap = 0; lap < laps_in_package; lap++) {
uint8_t* dblap = (lap_start_pos) + lap * 41; // packed sizeof(gh_db_lap)=41
gh_db_lap db_lap;
int recpoints_in_package = header.gh_laprec.EndPt - header.gh_ptrec.StartPt + 1;
// printf("Recpoints Data:\n");
uint8_t* recpoints_start_pos = track_payload + 29; //29=packed sizeof(gh_trainheader)
- int recpoint;
- for (recpoint = 0; recpoint < recpoints_in_package; recpoint++) {
+ for (int recpoint = 0; recpoint < recpoints_in_package; recpoint++) {
uint8_t* ghpoint = (recpoints_start_pos + recpoint * 25); // packed sizeof(gh_recpoint)=25
gh_recpoint point;
point.Latitude = be_read32(ghpoint);
static void
prescan_tags()
{
- tag_mapping* tm;
- for (tm = tag_path_map; tm->tag_type_ != 0; tm++) {
+ for (tag_mapping* tm = tag_path_map; tm->tag_type_ != 0; tm++) {
hash[tm->tag_name] = tm;
}
}
geocache_type
gs_mktype(const QString& t)
{
- int i;
int sz = sizeof(gs_type_map) / sizeof(gs_type_map[0]);
- for (i = 0; i < sz; i++) {
+ for (int i = 0; i < sz; i++) {
if (!t.compare(gs_type_map[i].name,Qt::CaseInsensitive)) {
return gs_type_map[i].type;
}
const char*
gs_get_cachetype(geocache_type t)
{
- int i;
int sz = sizeof(gs_type_map) / sizeof(gs_type_map[0]);
- for (i = 0; i < sz; i++) {
+ for (int i = 0; i < sz; i++) {
if (t == gs_type_map[i].type) {
return gs_type_map[i].name;
}
geocache_container
gs_mkcont(const QString& t)
{
- int i;
int sz = sizeof(gs_container_map) / sizeof(gs_container_map[0]);
- for (i = 0; i < sz; i++) {
+ for (int i = 0; i < sz; i++) {
if (!t.compare(gs_container_map[i].name,Qt::CaseInsensitive)) {
return gs_container_map[i].type;
}
const char*
gs_get_container(geocache_container t)
{
- int i;
int sz = sizeof(gs_container_map) / sizeof(gs_container_map[0]);
- for (i = 0; i < sz; i++) {
+ for (int i = 0; i < sz; i++) {
if (t == gs_container_map[i].type) {
return gs_container_map[i].name;
}
{
char name[9], desc[90];
unsigned char* HxWpt;
- int iCount;
int iDataRead;
int iWptNum;
WPT* pWptHxTmp;
iWptNum = le_read16(&((WPTHDR*)HxWpt)->num);
/* Get the waypoints */
- for (iCount = 0; iCount < iWptNum ; iCount ++) {
+ for (int iCount = 0; iCount < iWptNum ; iCount ++) {
Waypoint* wpt_tmp = new Waypoint;
int iWptIndex = le_read16(&((WPTHDR*)HxWpt)->idx[iCount]);
hrte.num = be_read16(&hrte.num);
if (hrte.count > 0) {
- int i;
route_head* rte = nullptr;
- for (i = 0; i < hrte.count; i++) {
+ for (int i = 0; i < hrte.count; i++) {
char buff[10];
hrte.points[i] = be_read16(&hrte.points[i]);
humminbird_trk_point_t* points;
route_head* trk;
Waypoint* first_wpt;
- int i;
int max_points = 0;
int32_t accum_east;
int32_t accum_north;
/* No depth info in the header. */
track_add_wpt(trk, first_wpt);
- for (i=0 ; i<th.num_points-1 ; i++) {
+ for (int i = 0 ; i<th.num_points-1 ; i++) {
Waypoint* wpt = new Waypoint;
int16_t next_deltaeast, next_deltanorth;
double guder;
humminbird_trk_point_old_t* points;
route_head* trk;
Waypoint* first_wpt;
- int i;
int max_points = 0;
int32_t accum_east;
int32_t accum_north;
first_wpt->altitude = 0.0;
track_add_wpt(trk, first_wpt);
- for (i=0 ; i<th.num_points-1 ; i++) {
+ for (int i = 0 ; i<th.num_points-1 ; i++) {
Waypoint* wpt = new Waypoint;
// int16_t next_deltaeast, next_deltanorth;
double guder;
}
if (humrte->count > 0) {
- int i;
-
humrte->num = rte_num++;
humrte->time = gpsbabel_time;
- for (i = 0; i < humrte->count; i++) {
+ for (int i = 0; i < humrte->count; i++) {
be_write16(&humrte->points[i], humrte->points[i]);
}
static void
lmx_indent(int count)
{
- int i;
- for (i=0; i<count; i++) {
+ for (int i = 0; i<count; i++) {
gbfputc('\t', ofd);
}
}
if (len < 0) {
fatal(MYNAME ": Invalid item length (%d)!\n", len);
} else if (len) {
- int i;
if (len > maxlen) {
len = maxlen;
}
}
// IWay 350C puts 0x01 for the accented o in the street name
// of the Montreal Holiday Inn.
- for (i = 0; i < len; i++) {
+ for (int i = 0; i < len; i++) {
if (buf[i] == 0x01) {
buf[i] = '*';
}
const QString
lowranceusr_find_desc_from_icon_number(const int icon)
{
- const lowranceusr_icon_mapping_t* i;
-
- for (i = lowranceusr_icon_value_table; i->icon; i++) {
+ for (const lowranceusr_icon_mapping_t* i = lowranceusr_icon_value_table; i->icon; i++) {
if (icon == i->value) {
return i->icon;
}
static int
lowranceusr_find_icon_number_from_desc(const QString& desc)
{
- const lowranceusr_icon_mapping_t* i;
int n;
if (desc.isNull()) {
}
- for (i = lowranceusr_icon_value_table; i->icon; i++) {
+ for (const lowranceusr_icon_mapping_t* i = lowranceusr_icon_value_table; i->icon; i++) {
if (desc.compare(i->icon,Qt::CaseInsensitive) == 0) {
return i->value;
}
{
char buff[MAXUSRSTRINGSIZE + 1];
short int num_icons;
- int i;
num_icons = gbfgetint16(file_in);
printf(MYNAME " parse_icons: num Icons = %d\n", num_icons);
}
- for (i=0; i < num_icons && !gbfeof(file_in); i++) {
+ for (int i = 0; i < num_icons && !gbfeof(file_in); i++) {
if (ignoreicons) {
/* position coord lat & long */
(void) gbfread(&buff[0], 4, 2, file_in);
bits (or more). for now let's just project the characters
down onto utf-8 space by ignoring all but the most
significant byte. */
- int i, j;
char discard;
- for (i = 0; i < len/bytes_per_char; ++i) {
+ for (int i = 0; i < len/bytes_per_char; ++i) {
bytesread += gbfread(&buf[i], 1, 1, file);
- for (j = 1; j < bytes_per_char; ++j) {
+ for (int j = 1; j < bytes_per_char; ++j) {
bytesread +=gbfread(&discard, 1, 1, file);
}
}
static void
register_waypt(const Waypoint* ref)
{
- int i;
Waypoint* wpt = const_cast<Waypoint*>(ref);
- for (i = 0; i < waypt_table_ct; i++) {
+ for (int i = 0; i < waypt_table_ct; i++) {
Waypoint* cmp = waypt_table[i];
if (same_points(wpt, cmp)) {
static int
lowranceusr4_find_waypt_index(const Waypoint* wpt)
{
- int i;
- for (i = 0; i < waypt_table_ct; ++i) {
+ for (int i = 0; i < waypt_table_ct; ++i) {
if (same_points(wpt, (const Waypoint*)waypt_table[i])) {
return i;
}
lowranceusr4_parse_waypoints()
{
short int icon_num;
- unsigned int i, num_waypts, create_date, create_time;
+ unsigned int num_waypts, create_date, create_time;
char buff[MAXUSRSTRINGSIZE + 1];
num_waypts = gbfgetint32(file_in);
printf(MYNAME " parse_waypoints: Num waypoints %d\n", num_waypts);
}
- for (i = 0; i < num_waypts; ++i) {
+ for (unsigned int i = 0; i < num_waypts; ++i) {
Waypoint* wpt_tmp;
wpt_tmp = new Waypoint;
static void
lowranceusr4_parse_routes()
{
- unsigned int num_routes, i, j, text_len;
+ unsigned int num_routes, text_len;
unsigned int num_legs;
char buff[MAXUSRSTRINGSIZE + 1];
Waypoint* wpt_tmp;
printf(MYNAME " parse_routes: Num routes = %d\n", num_routes);
}
- for (i = 0; i < num_routes; ++i) {
+ for (unsigned int i = 0; i < num_routes; ++i) {
rte_head = route_head_alloc();
route_add_head(rte_head);
rte_head->rte_num = i+1;
qPrintable(rte_head->rte_name), num_legs);
}
- for (j = 0; j < num_legs; ++j) {
+ for (unsigned int j = 0; j < num_legs; ++j) {
uid_unit = gbfgetint32(file_in);
uid_seq_low = gbfgetint32(file_in);
uid_seq_high = gbfgetint32(file_in);
static void
lowranceusr4_parse_trails()
{
- int num_trails, M, i, j, k, trk_num;
+ int num_trails, M, trk_num;
char buff[MAXUSRSTRINGSIZE + 1];
Waypoint* wpt_tmp;
printf(MYNAME " parse_trails: num trails = %d\n", num_trails);
}
- for (i = trk_num = 0; i < num_trails; ++i) {
+ for (int i = trk_num = 0; i < num_trails; ++i) {
trk_head = route_head_alloc();
trk_head->rte_num = ++trk_num;
track_add_head(trk_head);
trk_num, qPrintable(trk_head->rte_name), num_trail_pts);
}
- for (j = 0; j < num_trail_pts; ++j) {
+ for (int j = 0; j < num_trail_pts; ++j) {
wpt_tmp = new Waypoint;
/* Some unknown bytes */
/* Mysterious per-trackpoint data, toss it for now */
M = gbfgetint32(file_in);
- for (k = 0; k < M; ++k) {
+ for (int k = 0; k < M; ++k) {
gbfgetc(file_in);
gbfgetflt(file_in);
}
static void
lowranceusr4_write_waypoints()
{
- int i;
-
-/* enumerate all waypoints from both the plain old waypoint list and
+ /* enumerate all waypoints from both the plain old waypoint list and
also all routes */
waypt_table_sz = 0;
waypt_table_ct = 0;
gbfputint32(waypt_table_ct, file_out);
waypt_uid = 0;
- for (i = 0; i < waypt_table_ct; ++i) {
+ for (int i = 0; i < waypt_table_ct; ++i) {
if (global_opts.debug_level >= 2) {
printf(MYNAME " writing out waypt %d (%s - %s)\n",
i, qPrintable(waypt_table[i]->shortname), qPrintable(waypt_table[i]->description));
mag_checksum(const char* const buf)
{
int csum = 0;
- const char* p;
- for (p = buf; *p; p++) {
+ for (const char* p = buf; *p; p++) {
csum ^= *p;
}
Waypoint* waypt;
char* icons;
char* icone;
- char* blah;
int i = 0;
descr[0] = 0;
mag_dequote(descr);
- for (blah = icons ; blah < icone; blah++) {
+ for (char* blah = icons ; blah < icone; blah++) {
icon_token[i++] = *blah;
}
icon_token[i++] = '\0';
mkshort_new_handle()
#endif
{
- int i;
mkshort_handle_imp* h = (mkshort_handle_imp*) xxcalloc(sizeof *h, 1, file, line);
- for (i = 0; i < PRIME; i++) {
+ for (int i = 0; i < PRIME; i++) {
QUEUE_INIT(&h->namelist[i]);
}
mkshort_del_handle(short_handle* h)
{
mkshort_handle_imp* hdr = (mkshort_handle_imp*) *h;
- int i;
if (!h || !hdr) {
return;
}
- for (i = 0; i < PRIME; i++) {
+ for (int i = 0; i < PRIME; i++) {
queue* e, *t;
QUEUE_FOR_EACH(&hdr->namelist[i], e, t) {
uniq_shortname* s = (uniq_shortname*) e;
char*
delete_last_vowel(int start, char* istring, int* replaced)
{
- int l;
-
/*
* Basically impelement strrchr.
*/
*replaced = 0;
- for (l = strlen(istring); l > start; l--) {
+ for (int l = strlen(istring); l > start; l--) {
if (strchr(vowels, istring[l-1])) {
char* ostring;
/* If vowel is the first letter of a word, keep it.*/
#ifdef MMO_DBG
const char* sobj = "CObjTrack";
#endif
- int tp, ctp;
+ int tp;
route_head* trk;
DBG((sobj, ":-----------------------------------------------------\n"));
tp = gbfgetint16(fin);
DBG((sobj, "track has %d point(s)\n", tp));
- for (ctp = 0; ctp < tp; ctp++) {
+ for (int ctp = 0; ctp < tp; ctp++) {
Waypoint* wpt;
char unk;
static void
mmo_write()
{
- int i;
-
/* find out number of objects we have to write */
waypt_disp_all(mmo_enum_waypt_cb);
route_disp_all(mmo_enum_route_cb, nullptr, mmo_enum_waypt_cb);
gbfputuint16(mmo_obj_ct, fout);
mmo_write_obj_head("CObjIcons", "Unnamed object", gpsbabel_time, obj_type_ico);
- for (i = 0; i < 5; i++) {
+ for (int i = 0; i < 5; i++) {
gbfputuint16(0, fout);
}
static void
mtk_locus_read()
{
- int i;
-
track = route_head_alloc();
track_add_head(track);
dbg(1, "Track initialized\n");
read_line();
// initial serial buffer may contain garbage, so read until valid packet found
- for (i=0; i<10; i++) {
+ for (int i = 0; i<10; i++) {
process_packet();
read_line();
if (valid_packet_found) {
uint8_t calculated_checksum;
int hexval;
uint8_t fixbytes[16];
- int i;
- int wordnum;
int bytenum;
int fixnum;
static Waypoint* trkpt;
fixnum++;
bytenum = 0;
calculated_checksum = 0;
- for (wordnum=0; wordnum<4; wordnum++) { // 4 8-byte hex strings per fix
+ for (int wordnum = 0; wordnum<4; wordnum++) { // 4 8-byte hex strings per fix
if (token == nullptr) {
dbg(1, "Line %i: Fix %i incomplete data\n", packetnum, fixnum);
return;
}
- for (i=0; i<4; i++) {
+ for (int i = 0; i<4; i++) {
sscanf(&token[i * 2], "%2x", &hexval);
fixbytes[bytenum++] = hexval;
calculated_checksum ^= hexval;
int
calculate_checksum(const char* s, int length)
{
- int i;
int sum;
sum = 0;
- for (i=0; i<length; i++) {
+ for (int i = 0; i<length; i++) {
sum ^= *s++;
}
return sum;
static gbfile* cd;
static void mtk_csv_init(char* csv_fname, unsigned long bitmask)
{
- int i;
FILE* cf;
dbg(1, "Opening csv output file %s...\n", csv_fname);
/* Add the header line */
gbfprintf(cd, "INDEX,%s%s", ((1<<RCR) & bitmask)?"RCR,":"",
((1<<UTC) & bitmask)?"DATE,TIME,":"");
- for (i=0; i<32; i++) {
+ for (int i = 0; i<32; i++) {
if ((1<<i) & bitmask) {
switch (i) {
case RCR:
static int mtk_parse(unsigned char* data, int dataLen, unsigned int bmask)
{
static int count = 0;
- int i, k, sat_id, hspd;
+ int i, sat_id, hspd;
unsigned char crc, hbuf[4];
struct data_item itm;
dbg(5,"Entering mtk_parse, count = %i, dataLen = %i\n", count, dataLen);
if (global_opts.debug_level > 5) {
- int j;
fprintf(stderr,"# Data block:");
- for (j=0; j<dataLen; j++) {
+ for (int j = 0; j<dataLen; j++) {
fprintf(stderr,"%.2x ", data[j]);
}
fprintf(stderr,"\n");
memset(&itm, 0, sizeof(itm));
i = 0;
crc = 0;
- for (k=0; k<32; k++) {
+ for (int k = 0; k<32; k++) {
switch (((1<<k) & bmask)) {
case 1<<UTC:
itm.timestamp = le_read32(data + i);
/* update item checksum and length */
if (((1<<k) & bmask)) {
- int j;
- for (j=0; j<log_type[k].size; j++) {
+ for (int j = 0; j<log_type[k].size; j++) {
crc ^= data[i+j];
}
i += log_type[k].size;
static int mtk_log_len(unsigned int bitmask)
{
- int i, len;
+ int len;
/* calculate the length of a binary log item. */
switch (mtk_device) {
len = 2; // add '*' + crc
break;
}
- for (i=0; i<32; i++) {
+ for (int i = 0; i<32; i++) {
if ((1<<i) & bitmask) {
if (i > DISTANCE && global_opts.debug_level > 0) {
warning(MYNAME ": Unknown size/meaning of bit %d\n", i);
geocache_type
nc_mktype(const QString& t)
{
- int i;
int sz = sizeof(nc_type_map) / sizeof(nc_type_map[0]);
- for (i = 0; i < sz; i++) {
+ for (int i = 0; i < sz; i++) {
if (0 == t.compare(nc_type_map[i].name, Qt::CaseInsensitive)) {
return nc_type_map[i].type;
}
geocache_container
nc_mkcont(const QString& t)
{
- int i;
int sz = sizeof(nc_container_map) / sizeof(nc_container_map[0]);
- for (i = 0; i < sz; i++) {
+ for (int i = 0; i < sz; i++) {
if (0 == t.compare(nc_container_map[i].name, Qt::CaseInsensitive)) {
return nc_container_map[i].type;
}
static int
find_icon_from_descr(const QString& descr)
{
- unsigned int i;
-
- for (i = 0; i < sizeof(icon_table) / sizeof(const char*); i++) {
+ for (unsigned int i = 0; i < sizeof(icon_table) / sizeof(const char*); i++) {
if (0 == descr.compare(icon_table[i])) {
return i;
}
static void
free_waypoints(Waypoint** waypts)
{
- Waypoint** wayptp;
-
- for (wayptp = waypts; wayptp < waypts + MAX_WAYPOINTS; wayptp++) {
+ for (Waypoint** wayptp = waypts; wayptp < waypts + MAX_WAYPOINTS; wayptp++) {
if (*wayptp) {
delete *wayptp;
}
Waypoint** waypts = nullptr;
unsigned char information[32];
unsigned short total;
- unsigned short start;
if (global_opts.masked_objective & RTEDATAMASK) {
waypts = (Waypoint**) xcalloc(MAX_WAYPOINTS, sizeof(Waypoint*));
total = le_read16(information + 0);
- for (start = 0; start < total; start += 32) {
+ for (unsigned short start = 0; start < total; start += 32) {
unsigned short count = total - start;
unsigned char payload[7];
unsigned char* waypoints;
- unsigned char* w;
if (count > 32) {
count = 32;
read_packet(PID_DATA, waypoints, count * 32, count * 32, FALSE);
- for (w = waypoints; w < waypoints + count * 32; w = w + 32) {
+ for (unsigned char* w = waypoints; w < waypoints + count * 32; w = w + 32) {
if (global_opts.masked_objective & WPTDATAMASK) {
waypt_add(decode_waypoint(w));
}
unsigned short count = total < MAX_READ_TRACKPOINTS ? total : MAX_READ_TRACKPOINTS;
unsigned char payload[7];
unsigned char* trackpoints;
- unsigned char* t;
le_write32(payload + 0, address);
le_write16(payload + 4, count * 32);
read_packet(PID_DATA, trackpoints, count * 32, count * 32, FALSE);
write_packet(PID_ACK, nullptr, 0);
- for (t = trackpoints; t < trackpoints + count * 32; t = t + 32) {
+ for (unsigned char* t = trackpoints; t < trackpoints + count * 32; t = t + 32) {
track_add_wpt(track, decode_trackpoint(t));
}
{
unsigned char information[32];
unsigned char routec;
- unsigned char r;
write_packet(PID_QRY_INFORMATION, nullptr, 0);
read_packet(PID_DATA, information,
routec = information[2];
- for (r = 0; r < routec; r++) {
+ for (unsigned char r = 0; r < routec; r++) {
unsigned char payload[7];
unsigned char routedata[320];
route_head* route;
- int sr;
le_write32(payload + 0, r);
le_write16(payload + 2, 0);
route->rte_name = xstrdup((char*)routedata + 4);
route_add_head(route);
- for (sr = 0; sr < MAX_SUBROUTES; sr++) {
- int w;
-
- for (w = 0; w < MAX_SUBROUTE_LENGTH; w++) {
+ for (int sr = 0; sr < MAX_SUBROUTES; sr++) {
+ for (int w = 0; w < MAX_SUBROUTE_LENGTH; w++) {
unsigned short id = le_read16(routedata + 34 + 32 * sr + 2 *w);
if (id == 0xffffu) {
{
unsigned char* data;
unsigned src;
- unsigned sr;
unsigned char id[1];
QString rte_name;
data[30] = 0x7b;
data[31] = 0x77;
- for (sr = 0; sr < src; sr++) {
+ for (unsigned sr = 0; sr < src; sr++) {
unsigned char* srdata = data + 32 + 32 * sr;
unsigned pt_offset = MAX_SUBROUTE_LENGTH * sr;
- unsigned pt;
le_write16(srdata + 0, 0x2010);
- for (pt = 0; pt < MAX_SUBROUTE_LENGTH; pt++) {
+ for (unsigned pt = 0; pt < MAX_SUBROUTE_LENGTH; pt++) {
if (pt_offset + pt < route_id_ptr) {
le_write16(srdata + 2 + 2 * pt, route_ids[pt_offset + pt]);
} else {
unsigned int start_addr, unsigned int len)
{
unsigned char payload[7];
- unsigned char* p;
/* The protocol only supports reading 256 logpoints at once, so
* read small chunks until none left. */
read_packet(PID_DATA, logpoints, logpoints_len, logpoints_len, FALSE);
write_packet(PID_ACK, nullptr, 0);
- for (p = logpoints; p < logpoints + logpoints_len; p += 32) {
+ for (unsigned char* p = logpoints; p < logpoints + logpoints_len; p += 32) {
track_add_wpt(track, navilink_decode_logpoint(p));
}
static void
navitel_read_track()
{
- int points, i;
+ int points;
route_head* trk = nullptr;
points = gbfgetint32(fin);
(void) gbfgetint32(fin); /* unknown */
- for (i = 0; i < points; i++) {
+ for (int i = 0; i < points; i++) {
int lat, lon;
Waypoint* wpt;
while ((ibuf = gbfgetstr(file_in))) {
char* field;
- int field_num, len, i, stealth = 0;
+ int field_num, len, stealth = 0;
if ((line++ == 0) && file_in->unicode) {
cet_convert_init(CET_CHARSET_UTF8, 1);
if (!snmac) {
int found = 0;
/* check for all whitespace */
- for (i = 0; i < len && !found; i++) {
+ for (int i = 0; i < len && !found; i++) {
if (!isspace(ssid[i])) {
found = 1;
}
nmea_cksum(const char* const buf)
{
int x = 0 ;
- const char* p;
- for (p = buf; *p; p++) {
+ for (const char* p = buf; *p; p++) {
x ^= *p;
}
return x;
}
} else {
time_t prev;
- queue* elem;
tm.tm_hour = 23; /* last date found */
tm.tm_min = 59;
/* go backward through the track and complete timestamps */
- for (elem = QUEUE_LAST(&track->waypoint_list); elem != &track->waypoint_list; elem=elem->prev) {
+ for (queue* elem = QUEUE_LAST(&track->waypoint_list); elem != &track->waypoint_list; elem=elem->prev) {
Waypoint* wpt = (Waypoint*)elem;
if (wpt->wpt_flags.fmt_use != 0) {
static void
safe_print(int cnt, const char* b)
{
- int i;
- for (i = 0; i < cnt; i++) {
+ for (int i = 0; i < cnt; i++) {
char c = isprint(b[i]) ? b[i] : '.';
fputc(c, stderr);
}
{
char ibuf[1024];
static double lt = -1;
- int i;
int am_sirf = 0;
/*
* to get any better than we now have) hand that back to the caller.
*/
- for (i = 0; i < 10; i++) {
+ for (int i = 0; i < 10; i++) {
int rv;
ibuf[0] = 0;
rv = gbser_read_line(gbser_handle, ibuf, sizeof(ibuf), 2000, 0x0a, 0x0d);
static void
sirf_write(unsigned char* buf)
{
- int i, chksum = 0;
+ int chksum = 0;
int len = buf[2] << 8 | buf[3];
- for (i = 0; i < len; i++) {
+ for (int i = 0; i < len; i++) {
chksum += buf[4 + i];
}
chksum &= 0x7fff;
static void
osm_init_icons()
{
- int i;
-
if (!icons.isEmpty()) {
return;
}
- for (i = 0; osm_icon_mappings[i].value; i++) {
+ for (int i = 0; osm_icon_mappings[i].value; i++) {
icons.insert(QString::fromUtf8(osm_icon_mappings[i].icon),
&osm_icon_mappings[i]);
}
{
if (!wpt->shortname.isEmpty()) {
// The output might have a space or control character.
- int i, l = wpt->shortname.length();
+ int l = wpt->shortname.length();
char *t = (char*) xmalloc(l + 1);
char* d = t;
- for (i = 0; i < l; i++) {
+ for (int i = 0; i < l; i++) {
char s = wpt->shortname[i].cell();
if (isgraph(s)) {
*d++ = s;
Waypoint** comp;
int* qlist;
double dist, diff_time;
- int i = 0, j, anyitem;
+ int i = 0, anyitem;
comp = (Waypoint**) xcalloc(nelems, sizeof(*comp));
qlist = (int*) xcalloc(nelems, sizeof(*qlist));
anyitem = 0;
if (!qlist[i]) {
- for (j = i + 1 ; j < nelems ; j++) {
+ for (int j = i + 1 ; j < nelems ; j++) {
if (!qlist[j]) {
dist = gc_distance(comp[j]->latitude,
comp[j]->longitude,
static const char*
psit_find_desc_from_icon_number(const int icon)
{
- const psit_icon_mapping_t* i;
-
- for (i = psit_icon_value_table; i->icon; i++) {
+ for (const psit_icon_mapping_t* i = psit_icon_value_table; i->icon; i++) {
if (icon == i->value) {
return i->icon;
}
static int
psit_find_icon_number_from_desc(const char* desc)
{
- const psit_icon_mapping_t* i;
int def_icon = 18;
if (!desc) {
return def_icon;
}
- for (i = psit_icon_value_table; i->icon; i++) {
+ for (const psit_icon_mapping_t* i = psit_icon_value_table; i->icon; i++) {
if (case_ignore_strcmp(desc,i->icon) == 0) {
return i->value;
}
rand_str(const int maxlen, const char* fmt)
{
char* res;
- int i, len;
+ int len;
len = rand_int(maxlen) + 1;
res = (char*) xmalloc(len + 1);
res[len] = '\0';
- for (i = 0; i < len; i++) {
+ for (int i = 0; i < len; i++) {
int c = rand_int(26 + 26 + 10);
if (c < 26) {
c += 'a';
{
#define RND(a) (rand_int(a) > 0)
- int i, points;
+ int points;
route_head* head;
Waypoint* prev = nullptr;
time_t time = gpsbabel_time;
head = nullptr;
}
- for (i = 0; i < points; i++) {
+ for (int i = 0; i < points; i++) {
Waypoint* wpt;
garmin_fs_t* gmsd;
raymarine_read()
{
Waypoint* wpt;
- unsigned int ix;
- unsigned int rx;
/* Read all waypoints */
- for (ix = 0; ix < 0x3FFF; ix++) {
+ for (unsigned int ix = 0; ix < 0x3FFF; ix++) {
char sect[10];
char* str, *name, *lat, *lon;
/* Read all routes */
- for (rx = 0; rx < 0x3FFF; rx++) {
+ for (unsigned int rx = 0; rx < 0x3FFF; rx++) {
char sect[10];
char* name;
route_head* rte;
- int wx;
snprintf(sect, sizeof(sect), "Rt%d", rx);
if (nullptr == (name = inifile_readstr(fin, sect, "Name"))) {
rte->rte_name = name;
route_add_head(rte);
- for (wx = 0; wx < 0x3FFF; wx++) {
+ for (int wx = 0; wx < 0x3FFF; wx++) {
char buff[32];
char* str;
Waypoint* wpt;
static void
register_waypt(const Waypoint* ref, const char)
{
- int i;
Waypoint* wpt = const_cast<Waypoint*>(ref);
- for (i = 0; i < waypt_table_ct; i++) {
+ for (int i = 0; i < waypt_table_ct; i++) {
Waypoint* cmp = waypt_table[i];
if (same_points(wpt, cmp)) {
color_to_bbggrr(const char* opt_color)
{
int color_num;
- unsigned int i;
char* ep;
color_num = strtol(opt_color, &ep, 10);
return color_num;
}
- for (i = 0; i < sizeof(color_table) / sizeof(color_table[0]); i++) {
+ for (unsigned int i = 0; i < sizeof(color_table) / sizeof(color_table[0]); i++) {
if (0 == case_ignore_strcmp(opt_color, color_table[i].cn)) {
return (color_table[i].b << 16) +
(color_table[i].g << 8) +
static void
wr_buf(const unsigned char* str, int len)
{
- int i;
- for (i = 0; i < len; i++) {
+ for (int i = 0; i < len; i++) {
wr_char(str[i]);
}
}
static int
skytraq_calc_checksum(const unsigned char* buf, int len)
{
- int i, cs = 0;
- for (i = 0; i < len; i++) {
+ int cs = 0;
+ for (int i = 0; i < len; i++) {
cs ^= buf[i];
}
return cs;
skytraq_expect_ack(uint8_t id)
{
uint8_t ack_msg[2];
- int i/*, rcv_len*/;
+ //int rcv_len;
- for (i = 0; i < MSG_RETRIES; i++) {
+ for (int i = 0; i < MSG_RETRIES; i++) {
// rcv_len = skytraq_rd_msg(ack_msg, sizeof(ack_msg));
// if (rcv_len == sizeof(ack_msg)) {
if (skytraq_rd_msg(ack_msg, sizeof(ack_msg)) == res_OK) {
static int
skytraq_wr_msg_verify(const uint8_t* payload, int len)
{
- int i, rc;
+ int rc;
- for (i = 0; i < MSG_RETRIES; i++) {
+ for (int i = 0; i < MSG_RETRIES; i++) {
if (i > 0) {
db(1, "resending msg (id=0x%02x)...\n", payload[0]);
}
struct read_state st;
uint32_t log_wr_ptr;
uint16_t sectors_free, sectors_total, /*sectors_used_a, sectors_used_b,*/ sectors_used;
- int i, t, s, rc, got_sectors, total_sectors_read = 0;
+ int t, rc, got_sectors, total_sectors_read = 0;
int read_at_once = MAX(atoi(opt_read_at_once), 1);
int opt_first_sector_val = atoi(opt_first_sector);
int opt_last_sector_val = atoi(opt_last_sector);
db(1, MYNAME ": Reading log data from device...\n");
db(1, MYNAME ": start=%d used=%d\n", opt_first_sector_val, sectors_used);
db(1, MYNAME ": opt_last_sector_val=%d\n", opt_last_sector_val);
- for (i = opt_first_sector_val; i < sectors_used; i += got_sectors) {
+ for (int i = opt_first_sector_val; i < sectors_used; i += got_sectors) {
for (t = 0, got_sectors = 0; (t < SECTOR_RETRIES) && (got_sectors <= 0); t++) {
if (atoi(opt_read_at_once) == 0 || multi_read_supported == 0) {
rc = skytraq_read_single_sector(i, buffer);
continue; // skip decoding
}
- for (s = 0; s < got_sectors; s++) {
+ for (int s = 0; s < got_sectors; s++) {
db(4, MYNAME ": Decoding sector #%i...\n", i+s);
rc = process_data_sector(&st, buffer+s*SECTOR_SIZE, SECTOR_SIZE);
if (rc == 0) {
uint8_t odm_ver[4];
uint8_t revision[4];
} MSG_SOFTWARE_VERSION;
- int i, rc;
+ int rc;
// TODO: get current serial port baud rate and try that first
// (only sensible if init to 4800 can be disabled...)
baud_rates_count = 1;
}
- for (i = 0; i < baud_rates_count; i++) {
+ for (int i = 0; i < baud_rates_count; i++) {
db(1, MYNAME ": Probing SkyTraq Venus at %ibaud...\n", baud_rates[i]);
rd_drain();
skytraq_set_location()
{
double lat, lng;
- unsigned int i;
uint8_t MSG_SET_LOCATION[17] = { 0x36, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
uint8_t MSG_GET_LOCATION = 0x35;
sscanf(opt_set_location, "%lf:%lf", &lat, &lng);
le_write_double(&MSG_SET_LOCATION[1], lat);
le_write_double(&MSG_SET_LOCATION[9], lng);
- for (i=0; i<sizeof MSG_SET_LOCATION; i++) {
+ for (unsigned int i = 0; i<sizeof MSG_SET_LOCATION; i++) {
db(3, "%02x ", MSG_SET_LOCATION[i]);
}
db(3, "\n");
{
uint8_t MSG_GET_POI[3] = { 0x4D, 0, 0};
uint8_t buf[32];
- unsigned int poi;
double lat, lng, alt;
double ecef_x, ecef_y, ecef_z;
Waypoint* wpt;
- for (poi=0; poi<NUMPOI; poi++) {
+ for (unsigned int poi = 0; poi<NUMPOI; poi++) {
MSG_GET_POI[1]=(poi>>8)&0xff;
MSG_GET_POI[2]=(poi)&0xff;
if (skytraq_wr_msg_verify((uint8_t*)&MSG_GET_POI, sizeof(MSG_GET_POI)) != res_OK) {
static void
teletype_read()
{
- uint32_t i;
- for (i = 0; i < tty_wpt_count; i++) {
+ for (uint32_t i = 0; i < tty_wpt_count; i++) {
Waypoint* wpt = new Waypoint;
wpt->shortname = (gbfgetcstr(fin));
wpt->description = (gbfgetcstr(fin));
newblock->maxlat = maxlat;
newblock->size = 4 * 5 + 1; /* hdr is 5 longs, 1 char */
if (count < 20) {
- int i;
Waypoint* wpt = nullptr;
- for (i = 0; i < count; i++) {
+ for (int i = 0; i < count; i++) {
newblock->size += 4 * 3 + 1;
/* wpt const part 3 longs, 1 char */
wpt = start[i].wpt;
int latscale;
int lat = 0;
int lon = 0;
- unsigned int jj;
route_head* track_temp;
char rgb[7],bgr[7];
int bbggrr = 0;
// Process the track bytes
llvalid = 0;
- for (jj = 0; jj < track_byte_count;) {
+ for (unsigned int jj = 0; jj < track_byte_count;) {
Waypoint* waypoint_temp;
// Time to read a new latlong?
static void tpo_process_waypoints()
{
unsigned int waypoint_count;
- unsigned int ii;
//printf("Processing Waypoints...\n");
}
// Read/process each waypoint in the file
- for (ii = 0; ii < waypoint_count; ii++) {
+ for (unsigned int ii = 0; ii < waypoint_count; ii++) {
Waypoint* waypoint_temp;
Waypoint* waypoint_temp2;
unsigned int name_length;
static void tpo_process_map_notes()
{
unsigned int waypoint_count;
- unsigned int ii;
//printf("Processing Map Notes...\n");
}
// Process each waypoint
- for (ii = 0; ii < waypoint_count; ii++) {
+ for (unsigned int ii = 0; ii < waypoint_count; ii++) {
int lat;
int lon;
unsigned int name_length;
Waypoint* waypoint_temp;
unsigned int num_bytes;
- unsigned int jj;
//UNKNOWN DATA LENGTH
// block. May be 8/16/32 bits.
num_bytes = tpo_read_int();
//printf("num_bytes: %x\n", num_bytes);
- for (jj = 0; jj < num_bytes; jj++) {
+ for (unsigned int jj = 0; jj < num_bytes; jj++) {
(void) gbfgetc(tpo_file_in); // Skip bytes
}
static void tpo_process_symbols()
{
unsigned int waypoint_count;
- unsigned int ii;
//printf("Processing Symbols...\n");
}
// Process each waypoint
- for (ii = 0; ii < waypoint_count; ii++) {
+ for (unsigned int ii = 0; ii < waypoint_count; ii++) {
int lat;
int lon;
Waypoint* waypoint_temp;
static void tpo_process_text_labels()
{
unsigned int waypoint_count;
- unsigned int ii;
//printf("Processing Text Labels...\n");
}
// Process each waypoint
- for (ii = 0; ii < waypoint_count; ii++) {
- int jj;
+ for (unsigned int ii = 0; ii < waypoint_count; ii++) {
int lat;
int lon;
unsigned int name_length;
// Assign a generic waypoint name
waypoint_temp->shortname = QString("TXT %1").arg(ii + 1);
- for (jj = 0; jj < 16; jj++) {
+ for (int jj = 0; jj < 16; jj++) {
//UNKNOWN DATA LENGTH
(void) gbfgetc(tpo_file_in);
}
static void tpo_process_routes()
{
unsigned int route_count;
- unsigned int ii;
//printf("Processing Routes...\n");
// Read/process each route in the file
//
- for (ii = 0; ii < route_count; ii++) {
+ for (unsigned int ii = 0; ii < route_count; ii++) {
unsigned int name_length = 0;
- unsigned int jj;
unsigned int waypoint_cnt;
route_head* route_temp;
// Run through the list of waypoints, look up each in our
// index, then add the waypoint to this route.
//
- for (jj = 0; jj < waypoint_cnt; jj++) {
+ for (unsigned int jj = 0; jj < waypoint_cnt; jj++) {
Waypoint* waypoint_temp;
unsigned int val;
static void
tpo_rd_deinit()
{
- unsigned int i;
-
// Free the waypoint index, we don't need it anymore.
- for (i = 0; i < tpo_index_ptr; i++) {
+ for (unsigned int i = 0; i < tpo_index_ptr; i++) {
delete tpo_wp_index[i];
}
tpo_index_ptr = 0;
void TrackFilter::trackfilter_title()
{
- int i;
-
if (opt_title == nullptr) {
return;
}
if (strlen(opt_title) == 0) {
fatal(MYNAME "-title: Missing your title!\n");
}
- for (i = 0; i < track_ct; i++) {
+ for (int i = 0; i < track_ct; i++) {
route_head* track = track_list[i].track;
trackfilter_pack_init_rte_name(track, 0);
}
void TrackFilter::trackfilter_move()
{
- int i;
queue* elem, *tmp;
Waypoint* wpt;
time_t delta;
return;
}
- for (i = 0; i < track_ct; i++) {
+ for (int i = 0; i < track_ct; i++) {
route_head* track = track_list[i].track;
QUEUE_FOR_EACH((queue*)&track->waypoint_list, elem, tmp) {
wpt = (Waypoint*)elem;
void TrackFilter::trackfilter_synth()
{
- int i;
queue* elem, *tmp;
Waypoint* wpt;
fix = trackfilter_parse_fix(&nsats);
- for (i = 0; i < track_ct; i++) {
+ for (int i = 0; i < track_ct; i++) {
route_head* track = track_list[i].track;
first = 1;
QUEUE_FOR_EACH((queue*)&track->waypoint_list, elem, tmp) {
{
time_t start, stop;
queue* elem, *tmp;
- int i, dropped, inside = 0;
+ int dropped, inside = 0;
if (opt_start != nullptr) {
start = trackfilter_range_check(opt_start);
dropped = inside = 0;
- for (i = 0; i < track_ct; i++) {
+ for (int i = 0; i < track_ct; i++) {
route_head* track = track_list[i].track;
QUEUE_FOR_EACH((queue*)&track->waypoint_list, elem, tmp) {
void TrackFilter::trackfilter_seg2trk()
{
- int i;
-
- for (i = 0; i < track_ct; i++) {
+ for (int i = 0; i < track_ct; i++) {
queue* elem, *tmp;
route_head* src = track_list[i].track;
route_head* dest = nullptr;
void TrackFilter::trackfilter_trk2seg()
{
- int i, first;
+ int first;
route_head* master;
master = track_list[0].track;
- for (i = 1; i < track_ct; i++) {
+ for (int i = 1; i < track_ct; i++) {
queue* elem, *tmp;
route_head* curr = track_list[i].track;
"JAN", "FEB", "MAR", "APR", "MAY", "JUN",
"JUL", "AUG", "SEP", "OCT", "NOV", "DEC", nullptr
};
- const char** mp;
- for (mp = months; *mp; mp++) {
+ for (const char** mp = months; *mp; mp++) {
if (0 == case_ignore_strcmp(*mp, m)) {
return mp - months;
}
char*
strupper(char* src)
{
- char* c;
-
- for (c = src; *c; c++) {
+ for (char* c = src; *c; c++) {
*c = toupper(*c);
}
return src;
char*
strlower(char* src)
{
- char* c;
-
- for (c = src; *c; c++) {
+ for (char* c = src; *c; c++) {
*c = tolower(*c);
}
return src;
{
vecs_t* vec = vec_list;
while (vec->vec) {
- arglist_t* ap;
if (vec->vec->exit) {
(*vec->vec->exit)();
}
if (vec->vec->args) {
- for (ap = vec->vec->args; ap->argstring; ap++) {
+ for (auto ap = vec->vec->args; ap->argstring; ap++) {
if (ap->defaultvalue &&
(ap->argtype == ARGTYPE_INT) &&
! is_integer(ap->defaultvalue)) {
}
if (vec->vec->args) {
- for (arglist_t* ap = vec->vec->args; ap->argstring; ap++) {
+ for (auto ap = vec->vec->args; ap->argstring; ap++) {
const char* opt;
if (res) {
}
if (vec_list[0].vec->args) {
- for (arglist_t* ap = vec_list[0].vec->args; ap->argstring; ap++) {
+ for (auto ap = vec_list[0].vec->args; ap->argstring; ap++) {
const char* opt;
if (res) {
const size_t arglen = strlen(argname);
char* arglist;
char* rval = nullptr;
- char* arg;
char* argp;
if (!iarglist) {
arglist = xstrdup(iarglist);
- for (arg = arglist; argp = strtok(arg, ","), nullptr != argp; arg = nullptr) {
+ for (char* arg = arglist; argp = strtok(arg, ","), nullptr != argp; arg = nullptr) {
if (0 == case_ignore_strncmp(argp, argname, arglen)) {
/*
* If we have something of the form "foo=bar"
{
int vc;
vecs_t** svp;
- vecs_t* vec;
#if CSVFMTS_ENABLED
- style_vecs_t* svec;
#endif
int i = 0;
svp = (vecs_t**)xcalloc(vc, sizeof(style_vecs_t*));
/* Normal vecs are easy; populate the first part of the array. */
- for (vec = vec_list; vec->vec; vec++, i++) {
+ for (vecs_t* vec = vec_list; vec->vec; vec++, i++) {
svp[i] = vec;
if (svp[i]->parent == nullptr) {
svp[i]->parent = svp[i]->name;
#if CSVFMTS_ENABLED
/* Walk the style list, parse the entries, dummy up a "normal" vec */
- for (svec = style_list; svec->name; svec++, i++) {
+ for (style_vecs_t* svec = style_list; svec->name; svec++, i++) {
xcsv_read_internal_style(svec->style_buf);
svp[i] = (vecs_t*) xcalloc(1, sizeof** svp);
svp[i]->name = svec->name;
disp_vecs()
{
vecs_t** svp;
- arglist_t* ap;
int vc;
int i = 0;
continue;
}
printf(VEC_FMT, svp[i]->name, svp[i]->desc);
- for (ap = svp[i]->vec->args; ap && ap->argstring; ap++) {
+ for (auto ap = svp[i]->vec->args; ap && ap->argstring; ap++) {
if (!(ap->argtype & ARGTYPE_HIDDEN))
printf(" %-18.18s %s%-.50s %s\n",
ap->argstring,
disp_vec(const char* vecname)
{
vecs_t** svp;
- arglist_t* ap;
int vc;
int i = 0;
continue;
}
printf(VEC_FMT, svp[i]->name, svp[i]->desc);
- for (ap = svp[i]->vec->args; ap && ap->argstring; ap++) {
+ for (auto ap = svp[i]->vec->args; ap && ap->argstring; ap++) {
if (!(ap->argtype & ARGTYPE_HIDDEN))
printf(" %-18.18s %s%-.50s %s\n",
ap->argstring,
static void
disp_v2(ff_vecs_t* v)
{
- int i;
- for (i = 0; i < 3; i++) {
+ for (int i = 0; i < 3; i++) {
putchar((v->cap[i] & ff_cap_read) ? 'r' : '-');
putchar((v->cap[i] & ff_cap_write) ? 'w' : '-');
}
static void
disp_v3(const vecs_t* vec)
{
- arglist_t* ap;
-
disp_help_url(vec, nullptr);
- for (ap = vec->vec->args; ap && ap->argstring; ap++) {
+ for (auto ap = vec->vec->args; ap && ap->argstring; ap++) {
if (!(ap->argtype & ARGTYPE_HIDDEN)) {
printf("option\t%s\t%s\t%s\t%s\t%s\t%s\t%s",
vec->name,
{
vecs_t** svp;
vecs_t* vec;
- int i, vc = 0;
+ int vc = 0;
switch (version) {
case 0:
case 2:
case 3:
svp = sort_and_unify_vecs(&vc);
- for (i=0; i<vc; i++,vec++) {
+ for (int i = 0; i<vc; i++,vec++) {
vec = svp[i];
/* Version 1 displays type at front of all types.
static void buf_empty(struct buf_head* h)
{
- struct buf_chunk* chunk, *next;
- for (chunk = h->head; chunk; chunk = next) {
+ struct buf_chunk* next;
+ for (struct buf_chunk* chunk = h->head; chunk; chunk = next) {
next = chunk->next;
xfree(chunk);
}
static void buf_update_checksum(struct buf_head* h, const void* data, size_t len)
{
unsigned char* cp = (unsigned char*) data;
- unsigned i;
db(4, "Updating checksum with %p, %lu, before: %02x ",
data, (unsigned long) len, h->checksum);
- for (i = 0; i < len; i++) {
+ for (unsigned i = 0; i < len; i++) {
h->checksum ^= cp[i];
}
db(4, "after: %02x\n", h->checksum);
static wintec_gps_types guess_device()
{
- int i;
db(1, "Guessing device...\n");
- for (i = 0; i < 5; i++) {
+ for (int i = 0; i < 5; i++) {
if (wbt200_try()) {
return WBT200;
}
*/
static int do_cmd(const char* cmd, const char* expect, char* buf, int len)
{
- int trycount;
-
rd_drain();
wr_cmdl(cmd);
* NMEA data all the time so it's highly likely that it'll be in the
* middle of an NMEA sentence when we start listening.
*/
- for (trycount = 0; trycount < RETRIES; trycount++) {
+ for (int trycount = 0; trycount < RETRIES; trycount++) {
rd_line(buf, len);
db(3, "Got: %s\n", buf);
if (starts_with(buf, expect)) {
static int all_null(const void* buf, const int len)
{
const char* bp = (const char*) buf;
- int i;
- for (i = 0; i < len; i++) {
+ for (int i = 0; i < len; i++) {
if (bp[i]) {
return 0;
}
projects / gpsbabel.git / commitdiff